home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 May: Tool Chest / Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso / Tool Chest / Interfaces & Libraries / Interfaces / PInterfaces / FSM.p < prev    next >
Encoding:
Text File  |  1995-07-06  |  31.9 KB  |  903 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        FSM.p
  3.  
  4.      Contains:    HFS External File System Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT FSM;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __FSM__}
  30. {$SETC __FSM__ := 1}
  31.  
  32. {$I+}
  33. {$SETC FSMIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __FILES__}
  38. {$I Files.p}
  39. {$ENDC}
  40. {    Types.p                                                        }
  41. {        ConditionalMacros.p                                        }
  42. {    MixedMode.p                                                    }
  43. {    OSUtils.p                                                    }
  44. {        Memory.p                                                }
  45. {    Finder.p                                                    }
  46.  
  47. {$PUSH}
  48. {$ALIGN MAC68K}
  49. {$LibExport+}
  50. {$IFC OLDROUTINELOCATIONS }
  51.  
  52. CONST
  53.     volMountInteractBit            = 15;                            { Input to VolumeMount: If set, it's OK for the file system }
  54.     volMountInteractMask        = $8000;                        { to perform user interaction to mount the volume }
  55.     volMountChangedBit            = 14;                            { Output from VoumeMount: If set, the volume was mounted, but }
  56.     volMountChangedMask            = $4000;                        { the volume mounting information record needs to be updated. }
  57.     volMountFSReservedMask        = $00ff;                        { bits 0-7 are defined by each file system for its own use }
  58.     volMountSysReservedMask        = $ff00;                        { bits 8-15 are reserved for Apple system use }
  59.  
  60. {
  61.  * additional volume mount info record
  62.  }
  63.  
  64. TYPE
  65.     VolumeMountInfoHeader = RECORD
  66.         length:                    INTEGER;                                { length of location data (including self) }
  67.         media:                    VolumeType;                                { type of media (must be registered with Apple) }
  68.         flags:                    INTEGER;                                { volume mount flags. Variable length data follows }
  69.     END;
  70.  
  71.     VolumeMountInfoHeaderPtr = ^VolumeMountInfoHeader;
  72.  
  73.  
  74. CONST
  75.     gestaltFSMVersion            = 'fsm ';
  76.  
  77.     
  78. TYPE
  79.     VCBPtr = ^VCB;
  80.  
  81. {$ENDC}
  82.  
  83. CONST
  84.     fsUsrCNID                    = 16;                            { First assignable directory or file number }
  85. {    File system trap word attribute bits }
  86.     kHFSBit                        = 9;                            { HFS call: bit 9 }
  87.     kHFSMask                    = $0200;
  88.     kAsyncBit                    = 10;                            { Asynchronous call: bit 10 }
  89.     kAsyncMask                    = $0400;
  90.  
  91. {
  92.  * HFSCIProc selectCode values
  93.  * Note: The trap attribute bits (the HFS bit and the asynchronous bit)
  94.  * may be set in these selectCode values.
  95.  }
  96.     kFSMOpen                    = $A000;
  97.     kFSMClose                    = $A001;
  98.     kFSMRead                    = $A002;
  99.     kFSMWrite                    = $A003;
  100.     kFSMGetVolInfo                = $A007;
  101.     kFSMCreate                    = $A008;
  102.     kFSMDelete                    = $A009;
  103.     kFSMOpenRF                    = $A00A;
  104.     kFSMRename                    = $A00B;
  105.     kFSMGetFileInfo                = $A00C;
  106.     kFSMSetFileInfo                = $A00D;
  107.     kFSMUnmountVol                = $A00E;
  108.     kFSMMountVol                = $A00F;
  109.     kFSMAllocate                = $A010;
  110.     kFSMGetEOF                    = $A011;
  111.     kFSMSetEOF                    = $A012;
  112.     kFSMFlushVol                = $A013;
  113.     kFSMGetVol                    = $A014;
  114.     kFSMSetVol                    = $A015;
  115.     kFSMEject                    = $A017;
  116.     kFSMGetFPos                    = $A018;
  117.     kFSMOffline                    = $A035;
  118.     kFSMSetFilLock                = $A041;
  119.     kFSMRstFilLock                = $A042;
  120.     kFSMSetFilType                = $A043;
  121.     kFSMSetFPos                    = $A044;
  122.     kFSMFlushFile                = $A045;
  123. {    The File System HFSDispatch selectCodes }
  124.     kFSMOpenWD                    = $0001;
  125.     kFSMCloseWD                    = $0002;
  126.     kFSMCatMove                    = $0005;
  127.     kFSMDirCreate                = $0006;
  128.     kFSMGetWDInfo                = $0007;
  129.     kFSMGetFCBInfo                = $0008;
  130.     kFSMGetCatInfo                = $0009;
  131.     kFSMSetCatInfo                = $000A;
  132.     kFSMSetVolInfo                = $000B;
  133.     kFSMLockRng                    = $0010;
  134.     kFSMUnlockRng                = $0011;
  135.     kFSMCreateFileIDRef            = $0014;
  136.     kFSMDeleteFileIDRef            = $0015;
  137.     kFSMResolveFileIDRef        = $0016;
  138.     kFSMExchangeFiles            = $0017;
  139.     kFSMCatSearch                = $0018;
  140.     kFSMOpenDF                    = $001A;
  141.     kFSMMakeFSSpec                = $001B;
  142. {    The Desktop Manager HFSDispatch selectCodes }
  143.     kFSMDTGetPath                = $0020;
  144.     kFSMDTCloseDown                = $0021;
  145.     kFSMDTAddIcon                = $0022;
  146.     kFSMDTGetIcon                = $0023;
  147.     kFSMDTGetIconInfo            = $0024;
  148.     kFSMDTAddAPPL                = $0025;
  149.     kFSMDTRemoveAPPL            = $0026;
  150.     kFSMDTGetAPPL                = $0027;
  151.     kFSMDTSetComment            = $0028;
  152.     kFSMDTRemoveComment            = $0029;
  153.     kFSMDTGetComment            = $002A;
  154.     kFSMDTFlush                    = $002B;
  155.     kFSMDTReset                    = $002C;
  156.     kFSMDTGetInfo                = $002D;
  157.     kFSMDTOpenInform            = $002E;
  158.     kFSMDTDelete                = $002F;
  159. {    The AppleShare HFSDispatch selectCodes }
  160.     kFSMGetVolParms                = $0030;
  161.     kFSMGetLogInInfo            = $0031;
  162.     kFSMGetDirAccess            = $0032;
  163.     kFSMSetDirAccess            = $0033;
  164.     kFSMMapID                    = $0034;
  165.     kFSMMapName                    = $0035;
  166.     kFSMCopyFile                = $0036;
  167.     kFSMMoveRename                = $0037;
  168.     kFSMOpenDeny                = $0038;
  169.     kFSMOpenRFDeny                = $0039;
  170.     kFSMGetXCatInfo                = $003A;
  171.     kFSMGetVolMountInfoSize        = $003F;
  172.     kFSMGetVolMountInfo            = $0040;
  173.     kFSMVolumeMount                = $0041;
  174.     kFSMShare                    = $0042;
  175.     kFSMUnShare                    = $0043;
  176.     kFSMGetUGEntry                = $0044;
  177.     kFSMGetForeignPrivs            = $0060;
  178.     kFSMSetForeignPrivs            = $0061;
  179.  
  180. {
  181.  * UTDetermineVol status values
  182.  }
  183.     dtmvError                    = 0;                            { param error }
  184.     dtmvFullPathame                = 1;                            { determined by full pathname }
  185.     dtmvVRefNum                    = 2;                            { determined by volume refNum }
  186.     dtmvWDRefNum                = 3;                            { determined by working directory refNum }
  187.     dtmvDriveNum                = 4;                            { determined by drive number }
  188.     dtmvDefault                    = 5;                            { determined by default volume }
  189.  
  190. {
  191.  * UTGetBlock options
  192.  }
  193.     gbDefault                    = 0;                            { default value - read if not found }
  194. {    bits and masks }
  195.     gbReadBit                    = 0;                            { read block from disk (forced read) }
  196.     gbReadMask                    = $0001;
  197.     gbExistBit                    = 1;                            { get existing cache block }
  198.     gbExistMask                    = $0002;
  199.     gbNoReadBit                    = 2;                            { don't read block from disk if not found in cache }
  200.     gbNoReadMask                = $0004;
  201.     gbReleaseBit                = 3;                            { release block immediately after GetBlock }
  202.     gbReleaseMask                = $0008;
  203.  
  204. {
  205.  * UTReleaseBlock options
  206.  }
  207.     rbDefault                    = 0;                            { default value - just mark the buffer not in-use }
  208. {    bits and masks }
  209.     rbWriteBit                    = 0;                            { force write buffer to disk }
  210.     rbWriteMask                    = $0001;
  211.     rbTrashBit                    = 1;                            { trash buffer contents after release }
  212.     rbTrashMask                    = $0002;
  213.     rbDirtyBit                    = 2;                            { mark buffer dirty }
  214.     rbDirtyMask                    = $0004;
  215.     rbFreeBit                    = 3;                            { free the buffer (save in the hash) }
  216. {
  217.  *    rbFreeMask (rbFreeBit + rbTrashBit) works as rbTrash on < System 7.0 RamCache;
  218.  *    on >= System 7.0, rbfreeMask overrides rbTrash
  219.  }
  220.     rbFreeMask                    = $000A;
  221.  
  222. {
  223.  * UTFlushCache options
  224.  }
  225.     fcDefault                    = 0;                            { default value - just flush any dirty buffers }
  226. {    bits and masks }
  227.     fcTrashBit                    = 1;                            { trash buffers after flushing }
  228.     fcTrashMask                    = $0002;
  229.     fcFreeBit                    = 3;                            { free buffers after flushing }
  230.     fcFreeMask                    = $0008;                        { fcFreeMask works as fcTrash on < System 7.0 RamCache }
  231.  
  232. {
  233.  * UTCacheReadIP and UTCacheWriteIP cacheOption
  234.  }
  235.     noCacheBit                    = 5;                            { don't cache this please }
  236.     noCacheMask                    = $0020;
  237.     rdVerifyBit                    = 6;                            { read verify }
  238.     rdVerifyMask                = $0040;
  239.  
  240. {
  241.  * Cache routine internal error codes
  242.  }
  243.     chNoBuf                        = 1;                            { no free cache buffers (all in use) }
  244.     chInUse                        = 2;                            { requested block in use }
  245.     chnotfound                    = 3;                            { requested block not found }
  246.     chNotInUse                    = 4;                            { block being released was not in use }
  247.  
  248. {
  249.  * FCBRec.fcbFlags bits
  250.  }
  251.     fcbWriteBit                    = 0;                            { Data can be written to this file }
  252.     fcbWriteMask                = $01;
  253.     fcbResourceBit                = 1;                            { This file is a resource fork }
  254.     fcbResourceMask                = $02;
  255.     fcbWriteLockedBit            = 2;                            { File has a locked byte range }
  256.     fcbWriteLockedMask            = $04;
  257.     fcbSharedWriteBit            = 4;                            { File is open for shared write access }
  258.     fcbSharedWriteMask            = $10;
  259.     fcbFileLockedBit            = 5;                            { File is locked (write-protected) }
  260.     fcbFileLockedMask            = $20;
  261.     fcbOwnClumpBit                = 6;                            { File has clump size specified in FCB }
  262.     fcbOwnClumpMask                = $40;
  263.     fcbModifiedBit                = 7;                            { File has changed since it was last flushed }
  264.     fcbModifiedMask                = $80;
  265.  
  266. {
  267.  * ExtFileProc options
  268.  }
  269.     extendFileAllBit            = 0;                            { allocate all requested bytes or none }
  270.     extendFileAllMask            = $0001;
  271.     extendFileContigBit            = 1;                            { force contiguous allocation }
  272.     extendFileContigMask        = $0002;
  273.  
  274. {
  275.  *    HFS Component Interface constants
  276.  }
  277. {
  278.  * compInterfMask bits specific to HFS component
  279.  }
  280.     hfsCIDoesHFSBit                = 23;                            { set if file system supports HFS calls }
  281.     hfsCIDoesHFSMask            = $00800000;
  282.     hfsCIDoesAppleShareBit        = 22;                            { set if AppleShare calls supported }
  283.     hfsCIDoesAppleShareMask        = $00400000;
  284.     hfsCIDoesDeskTopBit            = 21;                            { set if Desktop Database calls supported }
  285.     hfsCIDoesDeskTopMask        = $00200000;
  286.     hfsCIDoesDynamicLoadBit        = 20;                            { set if dynamically loading code resource }
  287.     hfsCIDoesDynamicLoadMask    = $00100000;                    {        supported }
  288.     hfsCIResourceLoadedBit        = 19;                            { set if code resource already loaded }
  289.     hfsCIResourceLoadedMask        = $00080000;
  290.     hfsCIHasHLL2PProcBit        = 18;                            { set if FFS' log2PhyProc and Extendfile proc }
  291.     hfsCIHasHLL2PProcMask        = $00040000;                    { is written in a high level language. (i.e., uses Pascal calling convention) }
  292.  
  293. {
  294.  *    Disk Initialization Component Interface constants
  295.  }
  296. {
  297.  * compInterfMask bits specific to Disk Initialization component
  298.  }
  299.     diCIHasExtFormatParamsBit    = 18;                            { set if file system needs extended format }
  300.     diCIHasExtFormatParamsMask    = $00040000;                    {        parameters }
  301.     diCIHasMultiVolTypesBit        = 17;                            { set if file system supports more than one }
  302.     diCIHasMultiVolTypesMask    = $00020000;                    {        volume type }
  303.     diCIDoesSparingBit            = 16;                            { set if file system supports disk sparing }
  304.     diCIDoesSparingMask            = $00010000;
  305.     diCILiveBit                    = 0;                            { set if file system is candidate for current }
  306.     diCILiveMask                = $00000001;                    {        formatting operation (set by PACK2) }
  307.  
  308. {
  309.  * Disk Initialization Component Function selectors
  310.  }
  311.     diCILoad                    = 1;                            { Make initialization code memory resident }
  312.     diCIUnload                    = 2;                            { Make initialization code purgeable }
  313.     diCIEvaluateSizeChoices        = 3;                            { Evaluate size choices }
  314.     diCIExtendedZero            = 4;                            { Write an empty volume directory }
  315.     diCIValidateVolName            = 5;                            { Validate volume name }
  316.     diCIGetVolTypeInfo            = 6;                            { get volume type info }
  317.     diCIGetFormatString            = 7;                            { get dialog format string }
  318.     diCIGetExtFormatParams        = 8;                            { get extended format parameters }
  319.     diCIGetDefectList            = 9;                            { return the defect list for the indicated disk - reserved for future use }
  320.  
  321. {
  322.  * Constants used in the DICIEvaluateSizeRec and FormatListRec
  323.  }
  324.     diCIFmtListMax                = 8;                            { maximum number of format list entries in DICIEvaluateSizeRec.numSizeEntries }
  325. {    bits in FormatListRec.formatFlags: }
  326.     diCIFmtFlagsValidBit        = 7;                            { set if sec, side, tracks valid }
  327.     diCIFmtFlagsValidMask        = $80;
  328.     diCIFmtFlagsCurrentBit        = 6;                            { set if current disk has this fmt }
  329.     diCIFmtFlagsCurrentMask        = $40;
  330. {    bits in FormatListRec.sizeListFlags: }
  331.     diCISizeListOKBit            = 15;                            { set if this disk size usable }
  332.     diCISizeListOKMask            = $8000;
  333.  
  334. {
  335.  * DICIGetFormatStringRec.stringKind format strings
  336.  }
  337.     diCIAlternateFormatStr        = 1;                            { get alternate format  string (Balloon Help) }
  338.     diCISizePresentationStr        = 2;                            { get size presentation string (for dialog) }
  339.  
  340. {
  341.  * Error codes returned by Disk Sparing
  342.  }
  343.     diCIUserCancelErr            = 1;                            { user cancelled the disk init }
  344.     diCICriticalSectorBadErr    = 20;                            { critical sectors are bad (hopeless)    }
  345.     diCISparingFailedErr        = 21;                            { disk cannot be spared }
  346.     diCITooManyBadSectorsErr    = 22;                            { too many bad sectors }
  347.     diCIUnknownVolTypeErr        = 23;                            { the volume type passed in diCIExtendedZero paramBlock is not supported }
  348.     diCIVolSizeMismatchErr        = 24;                            { specified volume size doesn’t match with formatted disk size }
  349.     diCIUnknownDICallErr        = 25;                            { bogus DI function call selector }
  350.     diCINoSparingErr            = 26;                            { disk is bad but the target FS doesn't do disk sparing }
  351.     diCINoExtendInfoErr            = 27;                            { missing file system specific extra parameter in diCIExtendedZero call }
  352.     diCINoMessageTextErr        = 28;                            { missing message text in DIReformat call }
  353.  
  354. {
  355.  *    File System Manager constants
  356.  }
  357. {
  358.  * Miscellaneous constants used by FSM
  359.  }
  360.     fsdVersion1                    = 1;                            { current version of FSD record }
  361.     fsmIgnoreFSID                = $fffe;                        { this FSID should be ignored by the driver }
  362.     fsmGenericFSID                = $ffff;                        { unknown foreign file system ID }
  363.  
  364. {
  365.  * compInterfMask bits common to all FSM components
  366.  }
  367.     fsmComponentEnableBit        = 31;                            { set if FSM component interface is enabled }
  368.     fsmComponentEnableMask        = $80000000;
  369.     fsmComponentBusyBit            = 30;                            { set if FSM component interface is busy }
  370.     fsmComponentBusyMask        = $40000000;
  371.  
  372. {
  373.  * Selectors for GetFSInfo
  374.  }
  375.     fsmGetFSInfoByIndex            = -1;                            { get fs info by index }
  376.     fsmGetFSInfoByFSID            = 0;                            { get fs info by FSID }
  377.     fsmGetFSInfoByRefNum        = 1;                            { get fs info by file/vol refnum }
  378.  
  379. {
  380.  * InformFSM messages
  381.  }
  382.     fsmNopMessage                = 0;                            { nop }
  383.     fsmDrvQElChangedMessage        = 1;                            { DQE has changed }
  384.     fsmGetFSIconMessage            = 2;                            { Get FFS's disk icon }
  385.  
  386. {
  387.  * Messages passed to the fileSystemCommProc
  388.  }
  389.     ffsNopMessage                = 0;                            { nop, should always return noErr }
  390.     ffsGetIconMessage            = 1;                            { return disk icon and mask }
  391.     ffsIDDiskMessage            = 2;                            { identify the about-to-be-mounted volume }
  392.     ffsLoadMessage                = 3;                            { load in the FFS }
  393.     ffsUnloadMessage            = 4;                            { unload the FFS }
  394.     ffsIDVolMountMessage        = 5;                            { identify a VolMountInfo record }
  395.     ffsInformMessage            = 6;                            { FFS defined message }
  396.     ffsGetIconInfoMessage        = 7;
  397.  
  398. {
  399.  * Error codes from FSM functions
  400.  }
  401.     fsmFFSNotFoundErr            = -431;                            { Foreign File system does not exist - new Pack2 could return this error too }
  402.     fsmBusyFFSErr                = -432;                            { File system is busy, cannot be removed }
  403.     fsmBadFFSNameErr            = -433;                            { Name length not 1 <= length <= 31 }
  404.     fsmBadFSDLenErr                = -434;                            { FSD size incompatible with current FSM vers }
  405.     fsmDuplicateFSIDErr            = -435;                            { FSID already exists on InstallFS }
  406.     fsmBadFSDVersionErr            = -436;                            { FSM version incompatible with FSD }
  407.     fsmNoAlternateStackErr        = -437;                            { no alternate stack for HFS CI }
  408.     fsmUnknownFSMMessageErr        = -438;                            { unknown message passed to FSM }
  409.  
  410. {
  411.  *    HFS Utility routine records
  412.  }
  413. {
  414.  * record used by UTGetPathComponentName
  415.  }
  416.  
  417. TYPE
  418.     ParsePathRec = RECORD
  419.         namePtr:                StringPtr;                                { pathname to parse }
  420.         startOffset:            INTEGER;                                { where to start parsing }
  421.         componentLength:        INTEGER;                                { the length of the pathname component parsed }
  422.         moreName:                SignedByte;                                { non-zero if there are more components after this one }
  423.         foundDelimiter:            SignedByte;                                { non-zero if parsing stopped because a colon (:) delimiter was found }
  424.     END;
  425.  
  426.     ParsePathRecPtr = ^ParsePathRec;
  427.  
  428.     WDCBRec = RECORD
  429.         wdVCBPtr:                VCBPtr;                                    { Pointer to VCB of this working directory }
  430.         wdDirID:                LONGINT;                                { Directory ID number of this working directory }
  431.         wdCatHint:                LONGINT;                                { Hint for finding this working directory }
  432.         wdProcID:                LONGINT;                                { Process that created this working directory }
  433.     END;
  434.  
  435.     WDCBRecPtr = ^WDCBRec;
  436.  
  437.     FCBRec = RECORD
  438.         fcbFlNm:                LONGINT;                                { FCB file number. Non-zero marks FCB used }
  439.         fcbFlags:                SignedByte;                                { FCB flags }
  440.         fcbTypByt:                SignedByte;                                { File type byte }
  441.         fcbSBlk:                INTEGER;                                { File start block (in alloc size blks) }
  442.         fcbEOF:                    LONGINT;                                { Logical length or EOF in bytes }
  443.         fcbPLen:                LONGINT;                                { Physical file length in bytes }
  444.         fcbCrPs:                LONGINT;                                { Current position within file }
  445.         fcbVPtr:                VCBPtr;                                    { Pointer to the corresponding VCB }
  446.         fcbBfAdr:                Ptr;                                    { File's buffer address }
  447.         fcbFlPos:                INTEGER;                                { Directory block this file is in }
  448.         { FCB Extensions for HFS }
  449.         fcbClmpSize:            LONGINT;                                { Number of bytes per clump }
  450.         fcbBTCBPtr:                Ptr;                                    { Pointer to B*-Tree control block for file }
  451.         fcbExtRec:                ARRAY [0..2] OF LONGINT;                { First 3 file extents }
  452.         fcbFType:                OSType;                                    { File's 4 Finder Type bytes }
  453.         fcbCatPos:                LONGINT;                                { Catalog hint for use on Close }
  454.         fcbDirID:                LONGINT;                                { Parent Directory ID }
  455.         fcbCName:                Str31;                                    { CName of open file }
  456.     END;
  457.  
  458.     FCBRecPtr = ^FCBRec;
  459.  
  460. {
  461.  *    HFS Component Interface records
  462.  }
  463.     Lg2PhysProcPtr = ProcPtr;  { FUNCTION Lg2Phys(fsdGlobalPtr: UNIV Ptr; volCtrlBlockPtr: VCBPtr; fileCtrlBlockPtr: FCBRecPtr; fileRefNum: INTEGER; filePosition: LONGINT; reqCount: LONGINT; VAR volOffset: LONGINT; VAR contiguousBytes: LONGINT): OSErr; }
  464.     Lg2PhysUPP = UniversalProcPtr;
  465.  
  466. CONST
  467.     uppLg2PhysProcInfo = $003FEFE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  468.  
  469. FUNCTION NewLg2PhysProc(userRoutine: Lg2PhysProcPtr): Lg2PhysUPP;
  470.     {$IFC NOT GENERATINGCFM }
  471.     INLINE $2E9F;
  472.     {$ENDC}
  473.  
  474. FUNCTION CallLg2PhysProc(fsdGlobalPtr: UNIV Ptr; volCtrlBlockPtr: VCBPtr; fileCtrlBlockPtr: FCBRecPtr; fileRefNum: INTEGER; filePosition: LONGINT; reqCount: LONGINT; VAR volOffset: LONGINT; VAR contiguousBytes: LONGINT; userRoutine: Lg2PhysUPP): OSErr;
  475.     {$IFC NOT GENERATINGCFM}
  476.     INLINE $205F, $4E90;
  477.     {$ENDC}
  478. TYPE
  479.     HFSCIProcPtr = ProcPtr;  { FUNCTION HFSCI(theVCB: VCBPtr; selectCode: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; fsid: INTEGER): OSErr; }
  480.     HFSCIUPP = UniversalProcPtr;
  481.  
  482. CONST
  483.     uppHFSCIProcInfo = $0000BEE0; { FUNCTION (4 byte param, 2 byte param, 4 byte param, 4 byte param, 2 byte param): 2 byte result; }
  484.  
  485. FUNCTION NewHFSCIProc(userRoutine: HFSCIProcPtr): HFSCIUPP;
  486.     {$IFC NOT GENERATINGCFM }
  487.     INLINE $2E9F;
  488.     {$ENDC}
  489.  
  490. FUNCTION CallHFSCIProc(theVCB: VCBPtr; selectCode: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; fsid: INTEGER; userRoutine: HFSCIUPP): OSErr;
  491.     {$IFC NOT GENERATINGCFM}
  492.     INLINE $205F, $4E90;
  493.     {$ENDC}
  494.  
  495. TYPE
  496.     HFSCIRec = RECORD
  497.         compInterfMask:            LONGINT;                                { component flags }
  498.         compInterfProc:            HFSCIUPP;                                { pointer to file system call processing code }
  499.         log2PhyProc:            Lg2PhysUPP;                                { pointer to Lg2PhysProc() code }
  500.         stackTop:                Ptr;                                    { file system stack top }
  501.         stackSize:                LONGINT;                                { file system stack size }
  502.         stackPtr:                Ptr;                                    { current file system stack pointer }
  503.         reserved3:                LONGINT;                                { --reserved, must be zero-- }
  504.         idSector:                LONGINT;                                { Sector you need to ID a local volume. For networked volumes, this must be -1 }
  505.         reserved2:                LONGINT;                                { --reserved, must be zero-- }
  506.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  507.     END;
  508.  
  509.     HFSCIRecPtr = ^HFSCIRec;
  510.  
  511. {
  512.  *    Disk Initialization Component Interface records
  513.  }
  514.     DICIProcPtr = ProcPtr;  { FUNCTION DICI(whatFunction: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr): OSErr; }
  515.     DICIUPP = UniversalProcPtr;
  516.  
  517. CONST
  518.     uppDICIProcInfo = $00000FA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param): 2 byte result; }
  519.  
  520. FUNCTION NewDICIProc(userRoutine: DICIProcPtr): DICIUPP;
  521.     {$IFC NOT GENERATINGCFM }
  522.     INLINE $2E9F;
  523.     {$ENDC}
  524.  
  525. FUNCTION CallDICIProc(whatFunction: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; userRoutine: DICIUPP): OSErr;
  526.     {$IFC NOT GENERATINGCFM}
  527.     INLINE $205F, $4E90;
  528.     {$ENDC}
  529.  
  530. TYPE
  531.     DICIRec = RECORD
  532.         compInterfMask:            LONGINT;                                { component flags }
  533.         compInterfProc:            DICIUPP;                                { pointer to call processing code }
  534.         maxVolNameLength:        INTEGER;                                { maximum length of your volume name }
  535.         blockSize:                INTEGER;                                { your file system's block size }
  536.         reserved3:                LONGINT;                                { --reserved, must be zero-- }
  537.         reserved2:                LONGINT;                                { --reserved, must be zero-- }
  538.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  539.     END;
  540.  
  541.     DICIRecPtr = ^DICIRec;
  542.  
  543. {
  544.  * FormatListRec as returned by the .Sony disk driver's
  545.  * Return Format List status call (csCode = 6).
  546.  * If the status call to get this list for a drive is not
  547.  * implemented by the driver, then a list with one entry
  548.  * is contructed from the drive queue element for the drive.
  549.  }
  550.     FormatListRec = RECORD
  551.         volSize:                LONGINT;                                { disk capacity in SECTORs }
  552.         formatFlags:            SignedByte;                                { flags }
  553.         sectorsPerTrack:        SignedByte;                                { sectors per track side }
  554.         tracks:                    INTEGER;                                { number of tracks }
  555.     END;
  556.  
  557.     FormatListRecPtr = ^FormatListRec;
  558.  
  559. {
  560.  * SizeListRec built from FormatListRecs as described above.
  561.  }
  562.     SizeListRec = RECORD
  563.         sizeListFlags:            INTEGER;                                { flags as set by external file system }
  564.         sizeEntry:                FormatListRec;                            { disk driver format list record }
  565.     END;
  566.  
  567.     SizeListRecPtr = ^SizeListRec;
  568.  
  569. {
  570.  * paramBlock for the diCIEvaluateSize call
  571.  }
  572.     DICIEvaluateSizeRec = RECORD
  573.         defaultSizeIndex:        INTEGER;                                { default size for this FS }
  574.         numSizeEntries:            INTEGER;                                { number of size entries }
  575.         driveNumber:            INTEGER;                                { drive number }
  576.         sizeListPtr:            SizeListRecPtr;                            { ptr to size entry table }
  577.         sectorSize:                INTEGER;                                { bytes per sector }
  578.     END;
  579.  
  580.     DICIEvaluateSizeRecPtr = ^DICIEvaluateSizeRec;
  581.  
  582. {
  583.  * paramBlock for the diCIExtendedZero call
  584.  }
  585.     DICIExtendedZeroRec = RECORD
  586.         driveNumber:            INTEGER;                                { drive number }
  587.         volNamePtr:                StringPtr;                                { ptr to volume name string }
  588.         fsid:                    INTEGER;                                { file system ID }
  589.         volTypeSelector:        INTEGER;                                { volume type selector, if supports more than 1 type }
  590.         numDefectBlocks:        INTEGER;                                { number of bad logical blocks }
  591.         defectListSize:            INTEGER;                                { size of the defect list buffer in bytes }
  592.         defectListPtr:            Ptr;                                    { pointer to defect list buffer }
  593.         volSize:                LONGINT;                                { size of volume in SECTORs }
  594.         sectorSize:                INTEGER;                                { bytes per sector }
  595.         extendedInfoPtr:        Ptr;                                    { ptr to extended info }
  596.     END;
  597.  
  598.     DICIExtendedZeroRecPtr = ^DICIExtendedZeroRec;
  599.  
  600. {
  601.  * paramBlock for the diCIValidateVolName call
  602.  }
  603.     DICIValidateVolNameRec = PACKED RECORD
  604.         theChar:                CHAR;                                    { the character to validate }
  605.         hasMessageBuffer:        BOOLEAN;                                { false if no message }
  606.         charOffset:                INTEGER;                                { position of the current character (first char = 1) }
  607.         messageBufferPtr:        StringPtr;                                { pointer to message buffer or nil }
  608.         charByteType:            INTEGER;                                { theChar's byte type (smSingleByte, smFirstByte, or smLastByte) }
  609.     END;
  610.  
  611.     DICIValidateVolNameRecPtr = ^DICIValidateVolNameRec;
  612.  
  613. {
  614.  * paramBlock for the diCIGetVolTypeInfo call
  615.  }
  616.     DICIGetVolTypeInfoRec = RECORD
  617.         volSize:                LONGINT;                                { size of volume in SECTORs }
  618.         sectorSize:                INTEGER;                                { bytes per sector }
  619.         numVolTypes:            INTEGER;                                { number of volume types supported }
  620.         volTypesBuffer:            ARRAY [0..3] OF Str31;                    { 4 string buffers }
  621.     END;
  622.  
  623.     DICIGetVolTypeInfoRecPtr = ^DICIGetVolTypeInfoRec;
  624.  
  625. {
  626.  * paramBlock for the diCIGetFormatString call
  627.  }
  628.     DICIGetFormatStringRec = RECORD
  629.         volSize:                LONGINT;                                { volume size in SECTORs }
  630.         sectorSize:                INTEGER;                                { sector size }
  631.         volTypeSelector:        INTEGER;                                { volume type selector }
  632.         stringKind:                INTEGER;                                { sub-function = type of string }
  633.         stringBuffer:            Str255;                                    { string buffer }
  634.     END;
  635.  
  636.     DICIGetFormatStringRecPtr = ^DICIGetFormatStringRec;
  637.  
  638. {
  639.  * paramBlock for the diCIGetExtendedFormatParams call
  640.  }
  641.     DICIGetExtendedFormatRec = RECORD
  642.         driveNumber:            INTEGER;                                { drive number }
  643.         volTypeSelector:        INTEGER;                                { volume type selector or 0 }
  644.         volSize:                LONGINT;                                { size of volume in SECTORs }
  645.         sectorSize:                INTEGER;                                { bytes per sector }
  646.         fileSystemSpecPtr:        FSSpecPtr;                                { pointer to the foreign file system's FSSpec }
  647.         extendedInfoPtr:        Ptr;                                    { pointer to extended parameter structure }
  648.     END;
  649.  
  650.     DICIGetExtendedFormatRecPtr = ^DICIGetExtendedFormatRec;
  651.  
  652. {
  653.  *    File System Manager records
  654.  }
  655.     FSDCommProcPtr = ProcPtr;  { FUNCTION FSDComm(message: INTEGER; paramBlock: UNIV Ptr; globalsPtr: UNIV Ptr): OSErr; }
  656.     FSDCommUPP = UniversalProcPtr;
  657.  
  658. CONST
  659.     uppFSDCommProcInfo = $00000FA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param): 2 byte result; }
  660.  
  661. FUNCTION NewFSDCommProc(userRoutine: FSDCommProcPtr): FSDCommUPP;
  662.     {$IFC NOT GENERATINGCFM }
  663.     INLINE $2E9F;
  664.     {$ENDC}
  665.  
  666. FUNCTION CallFSDCommProc(message: INTEGER; paramBlock: UNIV Ptr; globalsPtr: UNIV Ptr; userRoutine: FSDCommUPP): OSErr;
  667.     {$IFC NOT GENERATINGCFM}
  668.     INLINE $205F, $4E90;
  669.     {$ENDC}
  670.  
  671. TYPE
  672.     FSDRec = RECORD
  673.         fsdLink:                ^FSDRec;                                { ptr to next }
  674.         fsdLength:                INTEGER;                                { length of this FSD in BYTES }
  675.         fsdVersion:                INTEGER;                                { version number }
  676.         fileSystemFSID:            INTEGER;                                { file system id }
  677.         fileSystemName:            Str31;                                    { file system name }
  678.         fileSystemSpec:            FSSpec;                                    { foreign file system's FSSpec }
  679.         fileSystemGlobalsPtr:    Ptr;                                    { ptr to file system globals }
  680.         fileSystemCommProc:        FSDCommUPP;                                { communication proc with the FFS }
  681.         reserved3:                LONGINT;                                { --reserved, must be zero-- }
  682.         reserved2:                LONGINT;                                { --reserved, must be zero-- }
  683.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  684.         fsdHFSCI:                HFSCIRec;                                { HFS component interface    }
  685.         fsdDICI:                DICIRec;                                { Disk Initialization component interface }
  686.     END;
  687.  
  688.     FSDRecPtr = ^FSDRec;
  689.  
  690.     FSMGetIconInfoRec = RECORD
  691.         theIcon:                ARRAY [0..31] OF LONGINT;                { The ICN# structure }
  692.         theMask:                ARRAY [0..31] OF LONGINT;                { The mask for the icon above }
  693.         whereStr:                Str255;
  694.     END;
  695.  
  696.     FSMGetIconInfoRecPtr = ^FSMGetIconInfoRec;
  697.  
  698. {
  699.  * paramBlock for ffsGetIconMessage and fsmGetFSIconMessage
  700.  }
  701.     FSMGetIconRec = RECORD
  702.         refNum:                    INTEGER;                                { target drive num or volume refnum }
  703.         iconBufferPtr:            FSMGetIconInfoRecPtr;                    { pointer to icon buffer }
  704.         requestSize:            LONGINT;                                { requested size of the icon buffer }
  705.         actualSize:                LONGINT;                                { actual size of the icon data returned }
  706.         iconType:                SInt8;                                    { kind of icon }
  707.         isEjectable:            BOOLEAN;                                { true if the device is ejectable }
  708.         driveQElemPtr:            DrvQElPtr;                                { pointer to DQE }
  709.         fileSystemSpecPtr:        FSSpecPtr;                                { pointer to foreign file system's FSSpec }
  710.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  711.     END;
  712.  
  713.     FSMGetIconRecPtr = ^FSMGetIconRec;
  714.  
  715. {
  716.  *    HFS Utility routine prototypes
  717.  }
  718.  
  719. FUNCTION UTAllocateFCB(VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  720.     {$IFC NOT GENERATINGCFM}
  721.     INLINE $7000, $A824;
  722.     {$ENDC}
  723. FUNCTION UTReleaseFCB(fileRefNum: INTEGER): OSErr;
  724.     {$IFC NOT GENERATINGCFM}
  725.     INLINE $7001, $A824;
  726.     {$ENDC}
  727. FUNCTION UTLocateFCB(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT; namePtr: StringPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  728.     {$IFC NOT GENERATINGCFM}
  729.     INLINE $7002, $A824;
  730.     {$ENDC}
  731. FUNCTION UTLocateNextFCB(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT; namePtr: StringPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  732.     {$IFC NOT GENERATINGCFM}
  733.     INLINE $7003, $A824;
  734.     {$ENDC}
  735. FUNCTION UTIndexFCB(volCtrlBlockPtr: VCBPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  736.     {$IFC NOT GENERATINGCFM}
  737.     INLINE $7004, $A824;
  738.     {$ENDC}
  739. FUNCTION UTResolveFCB(fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  740.     {$IFC NOT GENERATINGCFM}
  741.     INLINE $7005, $A824;
  742.     {$ENDC}
  743. FUNCTION UTAllocateVCB(VAR sysVCBLength: INTEGER; VAR volCtrlBlockPtr: VCBPtr; addSize: INTEGER): OSErr;
  744.     {$IFC NOT GENERATINGCFM}
  745.     INLINE $7006, $A824;
  746.     {$ENDC}
  747. FUNCTION UTAddNewVCB(driveNum: INTEGER; VAR vRefNum: INTEGER; volCtrlBlockPtr: VCBPtr): OSErr;
  748.     {$IFC NOT GENERATINGCFM}
  749.     INLINE $7007, $A824;
  750.     {$ENDC}
  751. FUNCTION UTDisposeVCB(volCtrlBlockPtr: VCBPtr): OSErr;
  752.     {$IFC NOT GENERATINGCFM}
  753.     INLINE $7008, $A824;
  754.     {$ENDC}
  755. FUNCTION UTLocateVCBByRefNum(refNum: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  756.     {$IFC NOT GENERATINGCFM}
  757.     INLINE $7009, $A824;
  758.     {$ENDC}
  759. FUNCTION UTLocateVCBByName(namePtr: StringPtr; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  760.     {$IFC NOT GENERATINGCFM}
  761.     INLINE $700A, $A824;
  762.     {$ENDC}
  763. FUNCTION UTLocateNextVCB(namePtr: StringPtr; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  764.     {$IFC NOT GENERATINGCFM}
  765.     INLINE $700B, $A824;
  766.     {$ENDC}
  767. FUNCTION UTAllocateWDCB(paramBlock: WDPBPtr): OSErr;
  768.     {$IFC NOT GENERATINGCFM}
  769.     INLINE $700C, $A824;
  770.     {$ENDC}
  771. FUNCTION UTReleaseWDCB(wdRefNum: INTEGER): OSErr;
  772.     {$IFC NOT GENERATINGCFM}
  773.     INLINE $700D, $A824;
  774.     {$ENDC}
  775. FUNCTION UTResolveWDCB(procID: LONGINT; wdIndex: INTEGER; wdRefNum: INTEGER; VAR wdCtrlBlockPtr: WDCBRecPtr): OSErr;
  776.     {$IFC NOT GENERATINGCFM}
  777.     INLINE $700E, $A824;
  778.     {$ENDC}
  779. FUNCTION UTFindDrive(driveNum: INTEGER; VAR driveQElementPtr: DrvQElPtr): OSErr;
  780.     {$IFC NOT GENERATINGCFM}
  781.     INLINE $700F, $A824;
  782.     {$ENDC}
  783. FUNCTION UTAdjustEOF(fileRefNum: INTEGER): OSErr;
  784.     {$IFC NOT GENERATINGCFM}
  785.     INLINE $7010, $A824;
  786.     {$ENDC}
  787. FUNCTION UTSetDefaultVol(nodeHint: LONGINT; dirID: LONGINT; refNum: INTEGER): OSErr;
  788.     {$IFC NOT GENERATINGCFM}
  789.     INLINE $7011, $A824;
  790.     {$ENDC}
  791. FUNCTION UTGetDefaultVol(paramBlock: WDPBPtr): OSErr;
  792.     {$IFC NOT GENERATINGCFM}
  793.     INLINE $7012, $A824;
  794.     {$ENDC}
  795. FUNCTION UTEjectVol(volCtrlBlockPtr: VCBPtr): OSErr;
  796.     {$IFC NOT GENERATINGCFM}
  797.     INLINE $702B, $A824;
  798.     {$ENDC}
  799. FUNCTION UTCheckWDRefNum(wdRefNum: INTEGER): OSErr;
  800.     {$IFC NOT GENERATINGCFM}
  801.     INLINE $7013, $A824;
  802.     {$ENDC}
  803. FUNCTION UTCheckFileRefNum(fileRefNum: INTEGER): OSErr;
  804.     {$IFC NOT GENERATINGCFM}
  805.     INLINE $7014, $A824;
  806.     {$ENDC}
  807. FUNCTION UTCheckVolRefNum(vRefNum: INTEGER): OSErr;
  808.     {$IFC NOT GENERATINGCFM}
  809.     INLINE $7015, $A824;
  810.     {$ENDC}
  811. FUNCTION UTCheckPermission(volCtrlBlockPtr: VCBPtr; VAR modByte: INTEGER; fileNum: LONGINT; paramBlock: ParmBlkPtr): OSErr;
  812.     {$IFC NOT GENERATINGCFM}
  813.     INLINE $7016, $A824;
  814.     {$ENDC}
  815. FUNCTION UTCheckVolOffline(vRefNum: INTEGER): OSErr;
  816.     {$IFC NOT GENERATINGCFM}
  817.     INLINE $7017, $A824;
  818.     {$ENDC}
  819. FUNCTION UTCheckVolModifiable(vRefNum: INTEGER): OSErr;
  820.     {$IFC NOT GENERATINGCFM}
  821.     INLINE $7018, $A824;
  822.     {$ENDC}
  823. FUNCTION UTCheckFileModifiable(fileRefNum: INTEGER): OSErr;
  824.     {$IFC NOT GENERATINGCFM}
  825.     INLINE $7019, $A824;
  826.     {$ENDC}
  827. FUNCTION UTCheckDirBusy(volCtrlBlockPtr: VCBPtr; dirID: LONGINT): OSErr;
  828.     {$IFC NOT GENERATINGCFM}
  829.     INLINE $701A, $A824;
  830.     {$ENDC}
  831. FUNCTION UTParsePathname(VAR volNamelength: INTEGER; namePtr: StringPtr): OSErr;
  832.     {$IFC NOT GENERATINGCFM}
  833.     INLINE $701B, $A824;
  834.     {$ENDC}
  835. FUNCTION UTGetPathComponentName(parseRec: ParsePathRecPtr): OSErr;
  836.     {$IFC NOT GENERATINGCFM}
  837.     INLINE $701C, $A824;
  838.     {$ENDC}
  839. FUNCTION UTDetermineVol(paramBlock: ParmBlkPtr; VAR status: INTEGER; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  840.     {$IFC NOT GENERATINGCFM}
  841.     INLINE $701D, $A824;
  842.     {$ENDC}
  843. FUNCTION UTGetBlock(refNum: INTEGER; log2PhyProc: UNIV Ptr; blockNum: LONGINT; gbOption: INTEGER; VAR buffer: Ptr): OSErr;
  844.     {$IFC NOT GENERATINGCFM}
  845.     INLINE $701F, $A824;
  846.     {$ENDC}
  847. FUNCTION UTReleaseBlock(buffer: Ptr; rbOption: INTEGER): OSErr;
  848.     {$IFC NOT GENERATINGCFM}
  849.     INLINE $7020, $A824;
  850.     {$ENDC}
  851. FUNCTION UTFlushCache(refNum: INTEGER; fcOption: INTEGER): OSErr;
  852.     {$IFC NOT GENERATINGCFM}
  853.     INLINE $7021, $A824;
  854.     {$ENDC}
  855. FUNCTION UTMarkDirty(buffer: Ptr): OSErr;
  856.     {$IFC NOT GENERATINGCFM}
  857.     INLINE $7023, $A824;
  858.     {$ENDC}
  859. FUNCTION UTTrashVolBlocks(volCtrlBlockPtr: VCBPtr): OSErr;
  860.     {$IFC NOT GENERATINGCFM}
  861.     INLINE $7024, $A824;
  862.     {$ENDC}
  863. FUNCTION UTTrashFileBlocks(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT): OSErr;
  864.     {$IFC NOT GENERATINGCFM}
  865.     INLINE $7025, $A824;
  866.     {$ENDC}
  867. FUNCTION UTTrashBlocks(beginPosition: LONGINT; byteCount: LONGINT; volCtrlBlockPtr: VCBPtr; fileRefNum: INTEGER; tbOption: INTEGER): OSErr;
  868.     {$IFC NOT GENERATINGCFM}
  869.     INLINE $7026, $A824;
  870.     {$ENDC}
  871. FUNCTION UTCacheReadIP(log2PhyProc: UNIV Ptr; filePosition: LONGINT; ioBuffer: Ptr; fileRefNum: INTEGER; reqCount: LONGINT; VAR actCount: LONGINT; cacheOption: INTEGER): OSErr;
  872.     {$IFC NOT GENERATINGCFM}
  873.     INLINE $7027, $A824;
  874.     {$ENDC}
  875. FUNCTION UTCacheWriteIP(log2PhyProc: UNIV Ptr; filePosition: LONGINT; ioBuffer: Ptr; fileRefNum: INTEGER; reqCount: LONGINT; VAR actCount: LONGINT; cacheOption: INTEGER): OSErr;
  876.     {$IFC NOT GENERATINGCFM}
  877.     INLINE $7028, $A824;
  878.     {$ENDC}
  879. FUNCTION UTBlockInFQHashP(vRefNum: INTEGER; diskBlock: LONGINT): OSErr;
  880.     {$IFC NOT GENERATINGCFM}
  881.     INLINE $702C, $A824;
  882.     {$ENDC}
  883. {
  884.  *    File System Manager call prototypes
  885.  }
  886. FUNCTION InstallFS(fsdPtr: FSDRecPtr): OSErr;
  887. FUNCTION RemoveFS(fsid: INTEGER): OSErr;
  888. FUNCTION SetFSInfo(fsid: INTEGER; bufSize: INTEGER; fsdPtr: FSDRecPtr): OSErr;
  889. FUNCTION GetFSInfo(selector: INTEGER; key: INTEGER; VAR bufSize: INTEGER; fsdPtr: FSDRecPtr): OSErr;
  890. FUNCTION InformFSM(theMessage: INTEGER; paramBlock: UNIV Ptr): OSErr;
  891. FUNCTION InformFFS(fsid: INTEGER; paramBlock: UNIV Ptr): OSErr;
  892.  
  893. {$ALIGN RESET}
  894. {$POP}
  895.  
  896. {$SETC UsingIncludes := FSMIncludes}
  897.  
  898. {$ENDC} {__FSM__}
  899.  
  900. {$IFC NOT UsingIncludes}
  901.  END.
  902. {$ENDC}
  903.